package basics.collections;

import java.util.*;
import java.util.concurrent.*;

/**
 * Java 集合框架详细知识点文档
 * 
 * 本文件提供了 Java 集合框架的全面详细介绍，从基础概念到高级应用，并与数组进行对比
 */
public class JavaCollectionsDetail {
    
    /**
     * 主方法 - 可以运行此类查看一些集合示例
     */
    public static void main(String[] args) {
        System.out.println("Java 集合框架详细知识点文档");
        System.out.println("请查看源代码中的注释获取详细信息");
        
        // 展示一些基本示例
        demonstrateCollectionBasics();
    }
    
    /**
     * 展示集合基础操作的方法
     */
    private static void demonstrateCollectionBasics() {
        // 创建并使用ArrayList
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");
        
        System.out.println("ArrayList示例: " + list);
        
        // 创建并使用HashSet
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(1); // 重复元素不会被添加
        
        System.out.println("HashSet示例: " + set);
        
        // 创建并使用HashMap
        Map<String, Integer> map = new HashMap<>();
        map.put("Java", 1995);
        map.put("Python", 1991);
        map.put("C++", 1983);
        
        System.out.println("HashMap示例: " + map);
    }
}

/**
 * =====================================================
 * 1. 集合框架概述
 * =====================================================
 * 
 * 1.1 什么是集合框架
 * - 集合框架是一个用于表示和操作集合的统一架构
 * - 包含接口、实现类和算法
 * - 位于java.util包中
 * - 解决了数组的局限性问题（固定大小、同质性等）
 * 
 * 1.2 集合框架与数组的对比
 * 
 * 数组:
 * - 固定长度，一旦创建不能改变大小
 * - 只能存储同一类型的元素
 * - 直接通过索引访问元素，性能好
 * - 内存连续分配，对基本类型友好
 * - 没有内置方法，需要借助Arrays工具类
 * 
 * 集合:
 * - 动态大小，可以根据需要增长或缩小
 * - 只能存储对象，不能存储基本类型（需要使用包装类）
 * - 提供了丰富的API和操作方法
 * - 支持泛型，提供类型安全
 * - 有多种实现类，适用于不同场景
 * 
 * 1.3 集合框架的层次结构
 * - Collection接口：集合层次的根接口
 *   - List接口：有序集合，允许重复元素
 *   - Set接口：不允许重复元素的集合
 *   - Queue接口：表示队列，通常以FIFO方式操作元素
 * - Map接口：键值对映射，不继承自Collection
 * 
 * =====================================================
 * 2. List接口及实现类
 * =====================================================
 * 
 * 2.1 List接口特点
 * - 有序集合（插入顺序）
 * - 允许重复元素
 * - 允许null元素
 * - 可以通过索引访问元素
 * 
 * 2.2 ArrayList
 * - 基于动态数组实现
 * - 随机访问效率高，时间复杂度O(1)
 * - 插入和删除效率低，可能需要移动元素
 * - 线程不安全
 * - 适用于：频繁随机访问，较少插入删除的场景
 * 
 * 示例:
 * List<String> arrayList = new ArrayList<>();
 * arrayList.add("Java");
 * arrayList.add("Python");
 * arrayList.get(0); // 获取第一个元素
 * arrayList.remove(1); // 删除第二个元素
 * 
 * 2.3 LinkedList
 * - 基于双向链表实现
 * - 随机访问效率低，时间复杂度O(n)
 * - 插入和删除效率高，时间复杂度O(1)
 * - 线程不安全
 * - 实现了Deque接口，可以用作队列或栈
 * - 适用于：频繁插入删除，较少随机访问的场景
 * 
 * 示例:
 * LinkedList<String> linkedList = new LinkedList<>();
 * linkedList.add("Java");
 * linkedList.addFirst("Python"); // 在头部添加元素
 * linkedList.addLast("C++"); // 在尾部添加元素
 * 
 * 2.4 Vector
 * - 类似ArrayList，但线程安全
 * - 性能较ArrayList差
 * - 已被Collections.synchronizedList()替代
 * - 不推荐使用
 * 
 * 2.5 Stack
 * - 继承自Vector
 * - 实现了LIFO（后进先出）栈
 * - 已被Deque接口的实现类替代
 * - 不推荐使用
 * 
 * =====================================================
 * 3. Set接口及实现类
 * =====================================================
 * 
 * 3.1 Set接口特点
 * - 不允许重复元素
 * - 最多包含一个null元素
 * - 没有定义顺序
 * 
 * 3.2 HashSet
 * - 基于HashMap实现
 * - 不保证元素顺序
 * - 允许null元素
 * - 查找、添加和删除的时间复杂度为O(1)
 * - 线程不安全
 * - 适用于：需要快速查找、不关心顺序的场景
 * 
 * 示例:
 * Set<String> hashSet = new HashSet<>();
 * hashSet.add("Java");
 * hashSet.add("Python");
 * hashSet.add("Java"); // 不会被添加，因为已存在
 * 
 * 3.3 LinkedHashSet
 * - 继承自HashSet
 * - 维护元素的插入顺序
 * - 性能略低于HashSet
 * - 适用于：需要保持插入顺序的场景
 * 
 * 示例:
 * Set<String> linkedHashSet = new LinkedHashSet<>();
 * linkedHashSet.add("Java");
 * linkedHashSet.add("Python");
 * // 遍历时会按照插入顺序返回元素
 * 
 * 3.4 TreeSet
 * - 基于红黑树（TreeMap）实现
 * - 元素按照自然顺序或指定的Comparator排序
 * - 不允许null元素
 * - 查找、添加和删除的时间复杂度为O(log n)
 * - 适用于：需要排序的场景
 * 
 * 示例:
 * TreeSet<String> treeSet = new TreeSet<>();
 * treeSet.add("Java");
 * treeSet.add("Python");
 * treeSet.add("C++");
 * // 遍历时会按照字母顺序返回元素
 * 
 * =====================================================
 * 4. Map接口及实现类
 * =====================================================
 * 
 * 4.1 Map接口特点
 * - 键值对映射
 * - 键不能重复
 * - 每个键最多映射到一个值
 * 
 * 4.2 HashMap
 * - 基于哈希表实现
 * - 不保证映射的顺序
 * - 允许null键和null值
 * - 查找、添加和删除的时间复杂度为O(1)
 * - 线程不安全
 * - 适用于：需要快速查找、不关心顺序的场景
 * 
 * 示例:
 * Map<String, Integer> hashMap = new HashMap<>();
 * hashMap.put("Java", 1995);
 * hashMap.put("Python", 1991);
 * hashMap.get("Java"); // 返回1995
 * 
 * 4.3 LinkedHashMap
 * - 继承自HashMap
 * - 维护键值对的插入顺序或访问顺序
 * - 性能略低于HashMap
 * - 适用于：需要保持插入顺序的场景
 * 
 * 示例:
 * Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
 * linkedHashMap.put("Java", 1995);
 * linkedHashMap.put("Python", 1991);
 * // 遍历时会按照插入顺序返回键值对
 * 
 * 4.4 TreeMap
 * - 基于红黑树实现
 * - 键按照自然顺序或指定的Comparator排序
 * - 不允许null键
 * - 查找、添加和删除的时间复杂度为O(log n)
 * - 适用于：需要按键排序的场景
 * 
 * 示例:
 * TreeMap<String, Integer> treeMap = new TreeMap<>();
 * treeMap.put("Java", 1995);
 * treeMap.put("Python", 1991);
 * treeMap.put("C++", 1983);
 * // 遍历时会按照键的字母顺序返回键值对
 * 
 * 4.5 Hashtable
 * - 类似HashMap，但线程安全
 * - 不允许null键和null值
 * - 性能较HashMap差
 * - 已被ConcurrentHashMap替代
 * - 不推荐使用
 * 
 * =====================================================
 * 5. Queue接口及实现类
 * =====================================================
 * 
 * 5.1 Queue接口特点
 * - 通常以FIFO（先进先出）方式操作元素
 * - 提供了额外的插入、提取和检查操作
 * 
 * 5.2 LinkedList
 * - 实现了Deque接口，可用作Queue
 * - 适用于：一般的队列操作
 * 
 * 示例:
 * Queue<String> queue = new LinkedList<>();
 * queue.offer("Java"); // 添加元素
 * queue.offer("Python");
 * queue.poll(); // 移除并返回队首元素
 * 
 * 5.3 PriorityQueue
 * - 基于优先级堆实现
 * - 元素按照自然顺序或指定的Comparator排序
 * - 不允许null元素
 * - 适用于：需要按优先级处理元素的场景
 * 
 * 示例:
 * PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
 * priorityQueue.offer(3);
 * priorityQueue.offer(1);
 * priorityQueue.offer(2);
 * priorityQueue.poll(); // 返回1，最小的元素
 * 
 * 5.4 Deque接口及实现类
 * - 双端队列，支持在两端插入和移除元素
 * - 可以用作栈或队列
 * - 主要实现类：LinkedList, ArrayDeque
 * 
 * 示例:
 * Deque<String> deque = new ArrayDeque<>();
 * deque.addFirst("Java"); // 在头部添加元素
 * deque.addLast("Python"); // 在尾部添加元素
 * deque.removeFirst(); // 移除并返回头部元素
 * deque.removeLast(); // 移除并返回尾部元素
 * 
 * =====================================================
 * 6. 集合的遍历方式
 * =====================================================
 * 
 * 6.1 使用Iterator
 * - 所有Collection实现类都支持Iterator
 * - 提供了统一的遍历方式
 * - 允许在遍历过程中安全地移除元素
 * 
 * 示例:
 * List<String> list = new ArrayList<>();
 * list.add("Java");
 * list.add("Python");
 * 
 * Iterator<String> iterator = list.iterator();
 * while (iterator.hasNext()) {
 *     String element = iterator.next();
 *     if (element.equals("Python")) {
 *         iterator.remove(); // 安全地移除元素
 *     }
 * }
 * 
 * 6.2 使用增强型for循环
 * - 简化了集合和数组的遍历
 * - 内部使用Iterator实现（对于集合）
 * - 不能在遍历过程中修改集合结构
 * 
 * 示例:
 * for (String element : list) {
 *     System.out.println(element);
 * }
 * 
 * 6.3 使用forEach方法（Java 8+）
 * - 结合Lambda表达式使用
 * - 更简洁的函数式风格
 * 
 * 示例:
 * list.forEach(element -> System.out.println(element));
 * // 或使用方法引用
 * list.forEach(System.out::println);
 * 
 * 6.4 遍历Map
 * - 使用entrySet()
 * - 使用keySet()和get()
 * - 使用forEach方法（Java 8+）
 * 
 * 示例:
 * Map<String, Integer> map = new HashMap<>();
 * map.put("Java", 1995);
 * map.put("Python", 1991);
 * 
 * // 使用entrySet
 * for (Map.Entry<String, Integer> entry : map.entrySet()) {
 *     System.out.println(entry.getKey() + ": " + entry.getValue());
 * }
 * 
 * // 使用forEach（Java 8+）
 * map.forEach((key, value) -> System.out.println(key + ": " + value));
 * 
 * =====================================================
 * 7. 集合的工具类
 * =====================================================
 * 
 * 7.1 Collections类
 * - 提供了操作集合的静态方法
 * - 类似于Arrays类对数组的操作
 * 
 * 7.2 常用方法
 * - sort(): 对List排序
 * - binarySearch(): 在有序List中查找元素
 * - reverse(): 反转List中元素的顺序
 * - shuffle(): 随机打乱List中元素的顺序
 * - fill(): 用指定元素替换List中的所有元素
 * - copy(): 将源List复制到目标List
 * - min()/max(): 查找集合中的最小/最大元素
 * - disjoint(): 检查两个集合是否没有共同元素
 * - frequency(): 计算集合中指定元素的出现次数
 * 
 * 示例:
 * List<Integer> numbers = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9));
 * Collections.sort(numbers); // 排序
 * Collections.reverse(numbers); // 反转
 * Collections.shuffle(numbers); // 随机打乱
 * int min = Collections.min(numbers); // 最小值
 * int max = Collections.max(numbers); // 最大值
 * int frequency = Collections.frequency(numbers, 1); // 计算1出现的次数
 * 
 * 7.3 不可修改的集合
 * - unmodifiableList/Set/Map(): 创建不可修改的视图
 * - 防止集合被修改
 * 
 * 示例:
 * List<String> list = new ArrayList<>();
 * list.add("Java");
 * list.add("Python");
 * List<String> unmodifiableList = Collections.unmodifiableList(list);
 * // unmodifiableList.add("C++"); // 抛出UnsupportedOperationException
 * 
 * 7.4 同步集合
 * - synchronizedList/Set/Map(): 创建线程安全的集合
 * - 为非线程安全的集合添加同步
 * 
 * 示例:
 * List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
 * // 现在可以在多线程环境中安全使用
 * 
 * =====================================================
 * 8. 并发集合
 * =====================================================
 * 
 * 8.1 并发集合概述
 * - 位于java.util.concurrent包中
 * - 专为多线程环境设计
 * - 提供比同步集合更好的并发性能
 * 
 * 8.2 ConcurrentHashMap
 * - 线程安全的HashMap
 * - 分段锁设计，提供更好的并发性
 * - 不允许null键和null值
 * 
 * 示例:
 * Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
 * concurrentMap.put("Java", 1995);
 * concurrentMap.put("Python", 1991);
 * 
 * 8.3 CopyOnWriteArrayList
 * - 线程安全的ArrayList
 * - 适用于读多写少的场景
 * - 每次修改都会创建一个新的底层数组副本
 * 
 * 示例:
 * List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
 * copyOnWriteList.add("Java");
 * copyOnWriteList.add("Python");
 * 
 * 8.4 CopyOnWriteArraySet
 * - 基于CopyOnWriteArrayList实现的线程安全Set
 * - 适用于读多写少的场景
 * 
 * 8.5 ConcurrentSkipListMap/Set
 * - 基于跳表实现的线程安全的有序Map/Set
 * - 提供类似TreeMap/TreeSet的功能，但线程安全
 * 
 * 8.6 BlockingQueue接口及实现类
 * - 支持阻塞操作的队列
 * - 主要实现类：ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue
 * - 适用于生产者-消费者模式
 * 
 * 示例:
 * BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(10);
 * blockingQueue.put("Java"); // 如果队列已满，会阻塞
 * String element = blockingQueue.take(); // 如果队列为空，会阻塞
 * 
 * =====================================================
 * 9. 集合与数组的互相转换
 * =====================================================
 * 
 * 9.1 数组转集合
 * - Arrays.asList(): 将数组转换为固定大小的List
 * - 注意：返回的List不支持add/remove操作
 * - 对于基本类型数组，需要使用包装类
 * 
 * 示例:
 * String[] array = {"Java", "Python", "C++"};
 * List<String> list = Arrays.asList(array);
 * // 创建可修改的ArrayList
 * List<String> modifiableList = new ArrayList<>(Arrays.asList(array));
 * 
 * 9.2 集合转数组
 * - Collection.toArray(): 将集合转换为数组
 * - 推荐使用带参数的toArray方法
 * 
 * 示例:
 * List<String> list = new ArrayList<>();
 * list.add("Java");
 * list.add("Python");
 * // 转换为String数组
 * String[] array = list.toArray(new String[0]);
 * 
 * =====================================================
 * 10. 集合的性能与选择
 * =====================================================
 * 
 * 10.1 集合选择考虑因素
 * - 是否需要有序集合
 * - 是否允许重复元素
 * - 是否需要键值对映射
 * - 是否需要线程安全
 * - 主要操作是什么（查找、插入、删除）
 * - 预期的数据量大小
 * 
 * 10.2 常见集合类的性能比较
 * 
 * ArrayList:
 * - 随机访问: O(1)
 * - 插入/删除: O(n)
 * - 查找: O(n)
 * - 适用场景: 频繁随机访问，较少插入删除
 * 
 * LinkedList:
 * - 随机访问: O(n)
 * - 插入/删除: O(1)（如果已有迭代器位置）
 * - 查找: O(n)
 * - 适用场景: 频繁插入删除，较少随机访问
 * 
 * HashSet/HashMap:
 * - 插入/删除/查找: O(1)
 * - 不保证顺序
 * - 适用场景: 需要快速查找，不关心顺序
 * 
 * TreeSet/TreeMap:
 * - 插入/删除/查找: O(log n)
 * - 元素有序
 * - 适用场景: 需要有序集合
 * 
 * 10.3 内存占用
 * - 集合比数组占用更多内存
 * - 每个元素都是对象，有额外的开销
 * - 集合类自身也有开销（如哈希表的桶）
 * 
 * 10.4 集合与数组的选择
 * - 固定大小、基本类型、性能关键场景：使用数组
 * - 动态大小、复杂操作、对象存储：使用集合
 * 
 * =====================================================
 * 11. Java 8+ 集合新特性
 * =====================================================
 * 
 * 11.1 Stream API
 * - 支持函数式风格操作集合
 * - 可以进行过滤、映射、归约等操作
 * - 支持并行处理
 * 
 * 示例:
 * List<String> names = Arrays.asList("Java", "Python", "C++", "JavaScript");
 * // 过滤以J开头的名称，转换为大写，并收集到新列表
 * List<String> filtered = names.stream()
 *                              .filter(name -> name.startsWith("J"))
 *                              .map(String::toUpperCase)
 *                              .collect(Collectors.toList());
 * 
 * 11.2 方法引用
 * - 简化Lambda表达式
 * - 更清晰地表达代码意图
 * 
 * 示例:
 * // 使用方法引用
 * names.forEach(System.out::println);
 * 
 * 11.3 Optional
 * - 避免空指针异常
 * - 更优雅地处理可能为null的值
 * 
 * 示例:
 * Optional<String> optional = Optional.ofNullable(getName());
 * optional.ifPresent(System.out::println);
 * String name = optional.orElse("Unknown");
 * 
 * 11.4 新的集合方法
 * - Map.computeIfAbsent/Present/Absent()
 * - Map.merge()
 * - Map.forEach()
 * - Collection.removeIf()
 * - List.replaceAll()
 * - Map.getOrDefault()
 * 
 * 示例:
 * Map<String, Integer> map = new HashMap<>();
 * // 如果键不存在，计算并添加值
 * map.computeIfAbsent("Java", k -> k.length());
 * // 获取值，如果键不存在返回默认值
 * int year = map.getOrDefault("Python", 0);
 */ 